package main

import (
	"encoding/gob"
	"io/ioutil"
	"math/rand"
	"os"
	"sync"
	"time"
)
import "fmt"
func main11() {
	//新建计时器，两秒以后触发，go触发计时器的方法比较特别，就是在计时器的channel中发送值
	timer1 := time.NewTimer(time.Second * 2)
	//此处在等待channel中的信号，执行此段代码时会阻塞两秒
	<-timer1.C
	fmt.Println("Timer 1 expired")
	//新建计时器，一秒后触发
	timer2 := time.NewTimer(time.Second)
	//新开启一个线程来处理触发后的事件
	go func() {
		//等触发时的信号
		<-timer2.C
		fmt.Println("Timer 2 expired")
	}()
	//由于上面的等待信号是在新线程中，所以代码会继续往下执行，停掉计时器
	stop2 := timer2.Stop()
	if stop2 {
		fmt.Println("Timer 2 stopped")
	}
	//test if exe

}
/**
*ticker只要定义完成，从此刻开始计时，不需要任何其他的操作，每隔固定时间都会触发。
*timer定时器，是到固定时间后会执行一次
*如果timer定时器要每隔间隔的时间执行，实现ticker的效果，使用 func (t *Timer) Reset(d Duration) bool
 */
func main13() {
	var wg sync.WaitGroup
	wg.Add(1)
	//NewTimer 创建一个 Timer，它会在最少过去时间段 d 后到期，向其自身的 C 字段发送当时的时间
	//timer1 := time.NewTimer(2 * time.Second)

	//NewTicker 返回一个新的 Ticker，该 Ticker 包含一个通道字段，并会每隔时间段 d 就向该通道发送当时的时间。它会调  //整时间间隔或者丢弃 tick 信息以适应反应慢的接收者。如果d <= 0会触发panic。关闭该 Ticker 可以释放相关资源。
	//ticker1 := time.NewTicker(2 * time.Second)
	//
	//go func(t *time.Ticker) {
	//	defer wg.Done()
	//	for {
	//		<-t.C
	//		time.Sleep(3*time.Second)
	//		fmt.Println("get ticker1", time.Now().Format("2006-01-02 15:04:05.000"))
	//
	//	}
	//}(ticker1)
	go func(){
		defer wg.Done()
		fmt.Println("get ticker1", time.Now().Format("2006-01-02 15:04:05.000"))
		timer:=time.NewTimer(0)
		for{
			<-timer.C
			fmt.Println("get next ticker1", time.Now().Format("2006-01-02 15:04:05.000"))
			return
		}

	}()
	//wg.Done()

	//go func(t *time.Timer) {
	//	defer wg.Done()
	//	for {
	//		<-t.C
	//		//t.r
	//		fmt.Println("get timer", time.Now().Format("2006-01-02 15:04:05.000"))
	//		t.Reset(2 * time.Second)
	//		//Reset 使 t 重新开始计时，（本方法返回后再）等待时间段 d 过去后到期。如果调用时 t 还在等待中会返回真；如果 t已经到期或者被停止了会返回假。
	//		time.Sleep(3*time.Second)
	//
	//	}
	//}(timer1)

	wg.Wait()
}
// lockedRand is a small wrapper around rand.Rand to provide
// synchronization among multiple raft groups. Only the methods needed
// by the code are exposed (e.g. Intn).
type lockedRand struct {
	mu   sync.Mutex
	rand *rand.Rand
}
func (r *lockedRand) Intn(n int) int {
	r.mu.Lock()
	v := r.rand.Intn(n)
	r.mu.Unlock()
	return v
}
var globalRand = &lockedRand{
	rand: rand.New(rand.NewSource(time.Now().UnixNano())),
}
func main(){
	//rand.Seed(time.Now().Unix())
	var wg sync.WaitGroup
	//wg.Add(1)
	for i:=0; i<10; i++ {
		wg.Add(1)
		go func(){
			seed:=time.Now().UnixNano()
			//rand.Seed(seed)
			fmt.Printf("%d,%d\n",seed,globalRand.Intn(150))
			wg.Done()
		}()
	}
	wg.Wait()
}

func inc(raw *int){
	*raw++;
}
//func main() {
//	counter := 0
//	counter++
//	fmt.Println("In main", counter)
//	inc(&counter)
//	fmt.Println("After inc", counter)
//}


type FileAll struct{
	Name string
	Cxt []byte
}

func main2(){
	var fal FileAll
	var err error
	fal.Name = os.Args[1]
	fal.Cxt,err = ioutil.ReadFile(os.Args[1])
	if err!=nil{
		panic(err)
	}
	enc:=gob.NewEncoder(os.Stdout)
	enc.Encode(fal)
}


